package edu.sandau.basic.service.impl;

import edu.sandau.basic.domain.role;
import edu.sandau.basic.global.GlobalEnum;
import edu.sandau.basic.mapper.roleMapper;
import edu.sandau.basic.service.RoleService;
import edu.sandau.basic.utils.Converter;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;
import org.springframework.transaction.support.TransactionSynchronizationManager;

import java.time.LocalDateTime;
import java.util.List;
import edu.sandau.basic.domain.roleExample;

@Service
public class RoleServiceImpl implements RoleService {
    @Resource
    private roleMapper roleMapper;

    @Override
    public GlobalEnum.ErrorCode addRole(role role) {
        GlobalEnum.ErrorCode errorCode = GlobalEnum.ErrorCode.UNKNOWN;

        // 设置创建和更新信息
        role.setCreatetime(Converter.localDateTimeToDate(LocalDateTime.now()));
        role.setUpdatetime(Converter.localDateTimeToDate(LocalDateTime.now()));
        role.setCreateperson(1); // 默认创建人ID为1
        role.setUpdateperson(1); // 默认更新人ID为1
        role.setIsActive(true); // 默认设置为激活状态

        // 插入角色
        int result = roleMapper.insert(role);
        if (result == 1) {
            errorCode = GlobalEnum.ErrorCode.OK;
        }

        return errorCode;
    }

    @Override
    public role getRoleById(Integer id) {
        return roleMapper.selectByPrimaryKey(id);
    }

    @Override
    public List<role> getAllRoles() {
        // 创建一个空的Example对象，用于查询所有记录
        roleExample example = new roleExample();
        return roleMapper.selectByExample(example);
    }

    @Override
    public GlobalEnum.ErrorCode deleteRoleByName(String name) {
        if (name == null || name.trim().isEmpty()) {
            return GlobalEnum.ErrorCode.UNKNOWN;
        }

        try {
            // 创建查询条件，根据角色代码查找角色
            roleExample example = new roleExample();
            roleExample.Criteria criteria = example.createCriteria();
            criteria.andRolecodeEqualTo(name);

            // 执行删除操作
            int result = roleMapper.deleteByExample(example);

            if (result > 0) {
                return GlobalEnum.ErrorCode.OK;
            } else {
                return GlobalEnum.ErrorCode.USER_NOT_EXIST;
            }
        } catch (Exception e) {
            // 记录异常日志
            e.printStackTrace();
            return GlobalEnum.ErrorCode.UNKNOWN;
        }
    }

    @Override
    public GlobalEnum.ErrorCode updateRoleByRolename(String rolecode, role role) {
        try {
            // 首先通过角色代码查找角色的ID
            roleExample example = new roleExample();
            roleExample.Criteria criteria = example.createCriteria();
            criteria.andRolecodeEqualTo(rolecode);
            List<role> roles = roleMapper.selectByExample(example);

            if (roles.isEmpty()) {
                return GlobalEnum.ErrorCode.USER_NOT_EXIST;
            }

            // 获取现有角色信息
            role existingRole = roles.get(0);

            // 创建一个新的role对象，只包含需要更新的字段
            role updateRole = new role();

            // 设置ID
            updateRole.setId(existingRole.getId());

            // 设置角色代码 - 只有当传入的角色代码与现有代码不同时才更新
            boolean hasChanges = false;
            if (role.getRolecode() != null && !role.getRolecode().equals(existingRole.getRolecode())) {
                updateRole.setRolecode(role.getRolecode());
                hasChanges = true;
            }

            // 只更新非空字段，并且只有当值不同时才更新
            if (role.getIsActive() != null && !role.getIsActive().equals(existingRole.getIsActive())) {
                updateRole.setIsActive(role.getIsActive());
                hasChanges = true;
            }

            // 保留创建时间和创建人字段不变 - 不设置这些字段，避免MyBatis更新它们
            // updateRole.setCreatetime(existingRole.getCreatetime());
            // updateRole.setCreateperson(existingRole.getCreateperson());

            // 总是设置更新时间和更新人，确保SQL语句完整
            updateRole.setUpdatetime(Converter.localDateTimeToDate(LocalDateTime.now()));
            updateRole.setUpdateperson(1);

            // 如果没有任何变化，至少设置一个字段确保SQL语句完整
            if (!hasChanges) {
                // 使用rolecode字段作为"占位符"，确保SET子句存在
                // 注意：这里设置的是数据库中的值，所以不会有实际变化
                updateRole.setRolecode(existingRole.getRolecode());
                updateRole.setIsActive(existingRole.getIsActive());
            }

            // 使用ID进行更新，避免主键冲突
            updateRole.setId(existingRole.getId());
            int result = roleMapper.updateByPrimaryKeySelective(updateRole);

            if (result > 0) {
                return GlobalEnum.ErrorCode.OK;
            } else {
                return GlobalEnum.ErrorCode.USER_NOT_EXIST;
            }
        } catch (Exception e) {
            // 记录异常日志
            e.printStackTrace();
            return GlobalEnum.ErrorCode.UNKNOWN;
        }
    }


    @Override
    public role getRoleByName(String name) {
        if (name == null || name.trim().isEmpty()) {
            return null;
        }

        try {
            // 创建查询条件，根据角色名查找角色
            roleExample example = new roleExample();
            roleExample.Criteria criteria = example.createCriteria();
            criteria.andRolecodeEqualTo(name);
            
            // 执行查询操作
            List<role> roles = roleMapper.selectByExample(example);
            
            if (!roles.isEmpty()) {
                return roles.get(0);
            } else {
                return null;
            }
        } catch (Exception e) {
            // 记录异常日志
            e.printStackTrace();
            return null;
        }
    }
}
